arrayFuncs.props - Code Metrics - Inspection of "minor fixes" - nightfury7/universalbasics.js - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 8d43c8...457e33 )

by Night
created 2018-07-24 14:10 UTC
arrayFuncs.props A

↳ Parent: src/ub.arrays.core.js
Complexity

Conditions	4
Paths	4
Size

Total Lines	12
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	9
nc	4
nop	2
dl	0
loc	12
rs	9.95
c	0
b	0
f	0
/** global: UB */
/** global: Buffer */

/*! ARRAY UTILS */

var arrayFuncs = {

	merge: function(){
		var arr = this;
		var val1 = arr[0];

		// if array of strings
		if (val1.isString()){
			return val1.join("");
		}

		// if array of arrays
		if (val1.isArray()){
			var merged = [];
			for (var a = 0, al = arr.length; a<al; a++){
				merged.addArray(arr[a]);
			}
			return merged;
		}

		// if array of Buffers
		//removeIf(nodejs)
		if (val1 instanceof Buffer){

			// calc the total length of all buffers
			var buffers = arr;
			var len = 0;
			for(var b = 0, bl = buffers.length; b < bl; b++) {
				len += buffers[b].length;
			}

			// create a new buffer of that length
			var mega = new Buffer(len);

			// write all buffers into the mega buffer
			var cur = 0;
			for(var b = 0, bl = buffers.length; b < bl; b++) {

				buffers[b].copy(mega, cur, 0);
				cur += buffers[b].length;
			}
			return mega;
		}
		//endRemoveIf(nodejs)

		return null;
	},
	
	indexOf: function(value){
		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = 0, al = list.length;a<al;a++){
			if (list[a] == value){
				return a;
			}
		}
		return -1;
	},
	indexOfNot: function(value){
		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = 0, al = list.length;a<al;a++){
			if (list[a] != value){
				return a;
			}
		}
		return -1;
	},
	lastIndexOf: function(value){

		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = list.length-1;a>=0;a--){
			if (list[a] == value){
				return a;
			}
		}
		return -1;
	},
	lastIndexOfNot: function(value){

		var list = this;
		if (list.length === 0) {
			return -1;
		}
		for (var a = list.length-1;a>=0;a--){
			if (list[a] != value){
				return a;
			}
		}
		return -1;
	},
	
	count: function(value, not = false){

		var list = this;
		var total = 0;
		for (var a = 0, al = list.length;a<al;a++){
			if (not) {
				if (list[a] != value) {
					total++;
				}
			}else {
				if (list[a] == value) {
					total++;
				}
			}
		}
		return total;
	},
	or: function(list2){
		var list = this;
		if (Exists(list)) {
			return list;
		}
		return list2;
	},
	
	part: function(start, end){
		var list = this;
		
		// quickly exit if no items or no results possible
		if (list == null || list.length === 0 || start > end || start >= list.length) {
			return [];
		}
		
		// just get the part we need
		return list.slice(start, end + 1);
	},
	
	swap: function(slot1, slot2){
		var list = this;
		var temp = list[slot2];
		list[slot2] = list[slot1];
		list[slot1] = temp;
	},

	add: function(item){
		var list = this;
		list.push(item);
		return list.length - 1;
	},
	addToStart: function(item){
		var list = this;
		list.unshift(item);
		return 0;
	},
	/** return false if item exists, true if item does not */
	addOnce: function(value){
		var list = this;
		
		// return false if item exists
		if (list.indexOf(value) > -1) {
			return false;
		}
		
		// add if not found
		list.push(value);
		return true;
	},
	
	addArray: function(toAdd, addAtSlot = -1, modifyMain = true){
		var list = this;
		
		if (toAdd != null && toAdd.length > 0) {
			if (!modifyMain) {
				list = list.concat(); /// shallow clone
			}
			
			// set length first so allocates memory (maybe?)
			var origLen = list.length;
			if (addAtSlot === -1){
				list.length += toAdd.length;
			}
			
			// set all slots
			var next = addAtSlot === -1 ? origLen : addAtSlot;
			for (var a = 0, al = toAdd.length;a<al;a++, next++){
				list[next] = toAdd[a];
			}
		}
		return list;
	},
	
	/** adds the given value many times */
	addManyTimes: function(val, times){
		var list = this;
		
		if (times <= 0) {
			return list;
		}
		
		var n = list.length;
		for (var t = 0;t<times;t++){
			list[n++] = val;
		}
		
		return list;
	},
	
	addRange: function(toAdd, startSlot, endSlot){
		var list = this;
		
		// exit if no work
		if (endSlot < startSlot) {
			return;
		}
		
		// per wanted slot of the `add` array
		startSlot = startSlot.limitToArray(toAdd);
		endSlot = endSlot.limitToArray(toAdd);
		for (var s = startSlot;s <= endSlot;s++){
			
			// add into `main` array
			list.push(toAdd[s]);
			
		}
	},
	
	/** returns final index of added item, or index of already existing item */
	findOrAdd: function(value){
		var list = this;
		
		// return index of item if exists
		var i = list.indexOf(value);
		if (i > -1) {
			return i;
		}
		
		// add if not found
		i = list.length;
		list[i] = value;
		return i;
	},
	
	insertOne: function(item, slot){
		var list = this;
		
		// adds one slot at the given point
		// modifies the main array
		
		list.splice(slot, 0, item);
	},

	/** if slot = -1 or outside the array, the item is added to the END of the array.
	 * Otherwise the item is added at the given slot. */
	insertOneOrAdd: function(item, slot){
		var list = this;
		
		// adds one slot at the given point
		// modifies the main array
		
		if (slot < 0 || slot >= list.length) {
			list.push(item);
			return list.length - 1;
		}
		list.splice(slot, 0, item);
		return slot;
	},
	insertArray: function(newItems, slot, returnNew = true){
		var list = this;
		
		// adds many slots at the given point
		// returns a new array
		if(returnNew){
			return list.slice(0, slot).concat(newItems).concat(list.slice(slot));
		}
		
		// adds many slots at the given point
		// modifies the main array
		for (var a = 0, al = newItems.length;a<al;a++){
			list.splice(slot++, 0, newItems[a]);
		}
		return list;
	},
	insertArrayAfter: function(newItems, after){
		var list = this;
		if (list.isLast(after)) {
			list.addArray(newItems);
		} else {
			var i = list.indexOf(after);
			list.insertArray(i + 1, newItems);
		}
	},
	

	removeAndInsert: function(from, to){
		var list = this;
		
		// ensure slots within array
		var al = list.length;
		from = from.limitTo(0, al - 1);
		to = to.limitTo(0, al - 1);
		if (to < from) {
			var i1 = to;
			var i2 = from;
		}else {
			i1 = from;
			i2 = to;
		}
		
		// fill unaffected header
		var result = [];
		if(i1 > 0){
			for (var a = 0;a<i1;a++){
				result[a] = list[a];
			}
		}
		
		// fill "to"
		result[to] = list[from];
		
		// fill between from and to
		if(to < from){
			for (a = to + 1; a <= from; a++) {
				result[a] = list[a - 1];
			}
		}else {
			for (a = from; a < to; a++) {
				result[a] = list[a + 1];
			}
		}
		
		// fill unaffected footer
		for (var a = i2 + 1;a<al;a++){

			result[a] = list[a];
		}
		
		return result;
	},
	
	/** replace a range of items with a given array */
	replaceRange: function(replaceStartSlot, replaceEndSlot, newItems, returnNew = true){
		var list = this;
		
		
		// simply remove a single item
		if (replaceStartSlot == replaceEndSlot && newItems.length === 0) {
			if (returnNew) {
				list = list.concat();
			}
			list.splice(replaceStartSlot, 1);
			return list;
			
		// simply replace a single item
		}else if (replaceStartSlot == replaceEndSlot && newItems.length === 1) {
			if (returnNew) {
				list = list.concat();
			}
			list[replaceStartSlot] = newItems[0];
			return list;
			
		}
		
		// alt method if returning a new array
		if(returnNew){
			return list.slice(0, replaceStartSlot).concat(newItems).concat(list.slice(replaceEndSlot + 1));
		}
		
		// remove many
		list.splice(replaceStartSlot, (replaceEndSlot - replaceStartSlot) + 1);
		
		// insert many
		var slot = replaceStartSlot;
		for (var a = 0, al = newItems.length;a<al;a++){
			list.splice(slot++, 0, newItems[a]);
		}
		return list;
	},
	
	replace: function(find, replace, stringReplace = false){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (stringReplace){

				// replace substring within string items
				var str = list[i];
				if (str && str.constructor === String) {
					list[i] = str.replaceAll(find, replace);
				}
			}else{

				// replace entire items
				if (list[i] == find) {
					list[i] = replace;
				}
			}
		}
	},
	replaceOnce: function(find, replace){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (list[i] == find) {
				list[i] = replace;
				return;
			}
		}
	},
	replaceMany: function(findArray, replaceArray){
		var list = this;
		if (findArray.length != replaceArray.length){
			return;
		}
		for (var i = 0, il = list.length;i<il;i++){
			for (var f = 0, fl = findArray.length;f<fl;f++){
				var find = findArray[f];
				if (list[i] == find) {
					list[i] = replaceArray[f];
					break;
				}
			}
		}
	},
	
	
	remove: function(value, stringReplace = false){
		var list = this;
		for (var i = 0, il = list.length;i<il;i++){
			if (stringReplace){

				// remove substring within string items
				var str = list[i];
				if (str && str.constructor === String) {
					list[i] = str.removeAll(value);
				}
			}else{

				// remove entire items
				if (list[i] == value) {
					list.splice(i, 1);
					i--;
					il--;
				}
			}
		}
	},
	removeOnce: function(val){
		var list = this;
		var i = list.indexOf(val);
		if (i > -1) {
			list.splice(i, 1);
		}
		return i;
	},
	removeFirst: function(returnNew = false){
		var list = this;

		// return new
		if (returnNew) {
			return list.slice(1);
		}

		// modify existing
		if (list.length > 0) {
			list.splice(0, 1);
		}
		return list;
	},
	removeFirstX: function(count, returnNew = false){
		var list = this;
		
		// if fewer items than wanted, clear entire array
		if (list.length < count) {
			if (returnNew) {
				return [];
			}
			list.length = 0;
			return list;
		}
		
		// delete X items from start
		// return new
		if (returnNew) {
			return list.slice(count);
		}

		// modify existing
		list.splice(0, count);
		return list;
	},
	removeLast: function(returnNew = false){
		var list = this;

		// return new
		if (returnNew) {
			return list.slice(0, list.length - 1);
		}

		// modify existing
		if (list.length > 0) {
			list.splice( - 1, 1);
		}
		return list;
	},
	removeLastX: function(count, returnNew = false){
		var list = this;
		
		// if fewer items than wanted, clear entire array
		if (list.length < count) {
			if (returnNew) {
				return [];
			}
			list.length = 0;
			return list;
		}
		
		// delete X items from end
		// return new
		if (returnNew) {
			return list.slice(0, list.length - count);
		}
		
		// modify existing
		list.splice( -count, count);
		return list;
	},
	
	removeEdges: function(fromLeftEdge, fromRightEdge){
		var list = this;
		if ((list.length - fromLeftEdge - fromRightEdge) <= 0) {
			return [];
		}
		return list.slice(fromLeftEdge, list.length - fromRightEdge);
	},
	
	removePart: function(start, end){
		var list = this;
		start = start.limitToArray(list);
		end = end.limitToArray(list);
		list.splice(start, (end-start)+1);
	},
	
	
	splitAt: function(slot, includeSlot = false, includeInFirst = false){
		var list = this;
		if (includeSlot) {
			if (includeInFirst) {
				return [list.slice(0, slot + 1), list.slice(slot + 1)];
			}
			return [list.slice(0, slot), list.slice(slot)];
		}
		return [list.slice(0, slot), list.slice(slot+1)];
	},
	splitAtEvery: function(seperator){
		var list = this;
		var splits = [];
		var lastSlot = 0;
		for (var a = 0, al = list.length;a<al;a++){
			if (list[a] == seperator && a > lastSlot) {
				splits.push(list.slice(lastSlot, a));
				lastSlot = a + 1;
			}
		}
		return splits;
	},
	
	moveToTop: function(slot, returnNew = false){
		var list = this;

		if (returnNew){


			// ALWAYS RETURNS NEW ARRAY
			
			// exit quickly if slot not in array
			var al = list.length;
			if (slot < 0 || slot >= al) {
				return list.concat();
			}
			
			// create new array with slot on top
			var newArr = [list[slot]];
			var n = 1;
			
			// add all other slots
			for (var a = 0;a<al;a++){
				if (a != slot) {
					newArr[n++] = list[a];
				}
			}

			return newArr;
		}


		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array
		var al = list.length;

		if (slot < 0 || slot >= al) {
			return;

		}
		
		// delete and re-add slot
		var val = list[slot];
		list.splice(slot, 1);
		list.unshift(val);

	},
	moveToBottom: function(slot, returnNew = false){
		var list = this;

		if (returnNew){


			// ALWAYS RETURNS NEW ARRAY
			
			// exit quickly if slot not in array
			var al = list.length;
			if (slot < 0 || slot >= al) {
				return list.concat();
			}
			
			// create new array with slot on top
			var newArr = [];
			var n = 0;
			
			// add all other slots
			for (var a = 0;a<al;a++){
				if (a != slot) {
					newArr[n++] = list[a];
				}
			}
			
			// add slot to bottom
			newArr[n++] = list[slot];

			return newArr;

		}

		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array
		var al = list.length;

		if (slot < 0 || slot >= al) {
			return;

		}
		
		// delete and re-add slot
		var val = list[slot];
		list.splice(slot, 1);
		list.push(val);

	},
	moveUp: function(item){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already on top
		var slot = list.indexOf(item);
		if (slot <= 0) {
			return false;
		}
		
		// move one up
		list.swap(slot, slot - 1);
		return true;
	},
	moveDown: function(item){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already at bottom
		var al = list.length;
		var slot = list.indexOf(item);
		if (slot < 0 || slot >= (al - 1)) {
			return false;
		}
		
		// move one down
		list.swap(slot, slot + 1);
		return true;
	},
	moveSlotUp: function(slot){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already on top
		var al = list.length;
		if (slot <= 0 || slot >= al) {
			return false;
		}
		
		// move one up
		list.swap(slot, slot - 1);
		return true;
	},
	moveSlotDown: function(slot){
		var list = this;
		
		// MODIFIES ARRAY IN PLACE
		
		// exit quickly if slot not in array, or already at bottom
		var al = list.length;
		if (slot < 0 || slot >= (al - 1)) {
			return false;
		}
		
		// move one down
		list.swap(slot, slot + 1);
		return true;
	},
	/** Move an item from the given list, to the start/end of the target list */
	moveToArray: function(item, toList, evenIfExists = false, addToEnd = true){
		var list = this;
		
		// remove from source list
		RemoveOne(list, item);
		
		// add to target list
		if (evenIfExists || toList.indexOf(item) === -1) {
			if (addToEnd) {
				toList.push(item);
			}else{
				toList.unshift(item);
			}
			return true;
		}
		
		return false;
	},

	
	contains: function(value){
		var list = this;
		if (list.length === 1) {
			return list[0] == value;
		}
		return list.indexOf(value) > -1;
	},
	containsAny: function(values){
		var list = this;
		return IndexOfAny(list, values) > -1;
	},
	containsAll: function(values){
		var list = this;
		
		// exit if either null
		if (list == null || values == null || list.length === 0 || values.length === 0) {
			return false;
		}
		
		// check if all found
		for (var f = 0, fl = values.length;f<fl;f++){
			if (list.indexOf(values[f]) === -1) {
				return false;
			}
		}
		return true;
	},
	

	indexOfArray: function(containsArr){
		var list = this;
		
		// returns index of containing list in main array
		
		if (list.length < containsArr.length) {
			return -1;
		}
		
		var cl = containsArr.length;
		for (var a = 0, al = list.length - (cl - 1);a<al;a++){
			
			var allMatch = true;
			for (var c = 0;c<cl;c++){
				if (list[a+c] != containsArr[c]) {
					allMatch = false;
					break;
				}
			}
			
			if (allMatch) {
				return a;
			}
		}
		return -1;
	},

	
	/** Returns the nearest existing slot value in the array. Returns `ifNoSlots` if the array is empty. */
	within: function(slot, ifNoSlots = null){
		var list = this;
		
		// return null if array empty
		var len = list.length;
		if (len === 0) {
			return ifNoSlots;
		}
		
		// return first slot if index negative
		if (slot < 0) {
			return list[0];
		}
		
		// return last slot if index more than last slot
		if (slot >= len) {
			return list[len - 1];
		}
		
		// return given slot if within array
		return list[slot];
	},
	
	first: function(list){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return null;
		}
		return list[0];
	},
	firstExisting: function(slots, blankVal = null){
		var list = this;
		for (var s = 0, sl = slots.length;s<sl;s++){
			var val;
			if ((val = list[slots[s]]) != blankVal) {
				return val;
			}
		}
		return null;
	},
	last: function(list){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return null;
		}
		return list[len-1];
	},
	lastX: function(count){
		var list = this;
		var s = (0).max(list.length - count);
		return list.slice(s, list.length);
	},
	setFirst: function(value){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return;
		}
		list[0] = value;
	},
	setLast: function(value){
		var list = this;
		var len = list.length;
		if (len === 0) {
			return;
		}
		list[len-1] = value;
	},
	
	random: function(list){
		var list = this;
		
		// return null if array empty
		if (list.length === 0) {
			return null;
		}
		
		// return random slot within array
		return list[parseInt(Math.random() * 1000000) % list.length];
	},

	pick: function(slots){

		var list = this;
		var out = [];
		
		if (!slots){
			return out;
		}

		for (var i = 0, il = slots.length;i<il;i++){
			id = slots[i];

			val = list[id];

			if (val != null) {
				out.push(val);
			}
		}
		return out;
	},

	pickMatching: function(slots, evenIfNull = false){

		var list = this;
		var out = [];
		
		if (!slots){
			return out;
		}
		
		for (var i = 0, il = slots.length;i<il;i++){
			id = slots[i];

			val = list[id];

			if (val != null || evenIfNull) {
				out[id] = val;
			}
		}
		return out;
	},

	/** Get the data of `list`, by searching `indexID` in `indexArr`, or return `defaultVal` if not found */
	getByMatchingArray: function(indexArr, indexID, defaultVal = null){
		var list = this;
		var slot = indexArr.indexOf(indexID);
		return slot === -1 ? defaultVal : list[slot];
	},
	/** Set the data of `list`, by searching `indexID` in `indexArr` */
	setByMatchingArray: function(indexArr, indexID, data){
		var list = this;
		var slot = indexArr.indexOf(indexID);
		if (slot === -1) {
			return false;
		}
		list[slot] = data;
		return true;
	},
	
	page: function(page, pageLength, invisibleRows = null){
		var list = this;
		
		// ensure page no. in limits
		var lastPage = Math.ceil(list.length / pageLength);
		page = page.limitTo(0, lastPage - 1);
		
		// get first/last row in page
		var pageStart = page*pageLength;/// 0-based - first row in page
		var pageEnd = (pageStart + pageLength) - 1;/// 0-based - last row in page
		
		// get on-page rows
		var visibleRows = list.part(pageStart, pageLength);
		
		// get off-page rows
		if (invisibleRows) {
			invisibleRows.addRange(list, 0, pageStart - 1);
			invisibleRows.addRange(list, pageEnd + 1, list.length - 1);
		}
		
		return visibleRows;
	},
	
	trim: function(returnNew = false, trimVal = null){
		var list = this;
		var first = list.indexOfNot(trimVal);
		if (first === -1) {

			// return new
			if (returnNew) {
				return [];
			}

			// modify existing
			list.length = 0;
		}else{

			// return new
			var last = list.lastIndexOfNot(trimVal);
			if (returnNew) {
				return list.part(first, last);
			}

			// modify existing
			if (first != -1 && first != 0){
				list.removePart(0, first-1);
			}
			if (last != -1){
				list.length = last - first + 1; 
			}
		}
		return list;
	},

	trimLeft: function(returnNew = false, trimVal = null){
		var list = this;
		var first = list.indexOfNot(trimVal);
		if (first === -1) {

			// return new
			if (returnNew) {
				return [];
			}

			// modify existing
			list.length = 0;

		}else{

			// return new
			if (returnNew) {
				return list.afterIndex(first);
			}

			// modify existing
			if (first != -1 && first != 0){
				list.removePart(0, first-1);
			}
		}
		return list;
	},
	trimRight: function(returnNew = false, trimVal = null){
		var list = this;
		var last = list.indexOfNot(trimVal, true);
		if (last === -1) {

			// return new
			if (returnNew) {
				return [];
			}
			
			// modify existing
			list.length = 0;
		}else{

			// return new
			if (returnNew) {
				return list.beforeIndex(last);
			}

			// modify existing
			list.length = last + 1;
		}
		return list;
	},
	
	transpose: function() {
		var arr = this;
		var transposed = [];
		
		for (var r = 0; r < arr.length; r++) {
			for (var c = 0; c < arr[r].length; c++) {
				if (transposed[c] == null) {
					transposed[c] = [];
				}
				transposed[c][r] = arr[r][c];
			}
		}
		
		return transposed;
	},
	
	
	// fast sorting
	quickSort: function(ascending = true){
		var input = this;
		
		var len = input.length;
		if (len >= 2) {
			
			// sort in place
			input._quickSort(0, len - 1, 0);
			
			// flip if descending wanted
			if (!ascending) {
				input.reverse();
			}
			
		}
	},

	indexedQuickSort: function(ascending = true){
		var input = this;
		
		var len = input.length;
		if (len >= 2) {
			
			// indexed sort
			var index = UB.newArray(0, input.length);
			input._indexedQuickSort(index, 0, len - 1, 0);
			
			// flip if descending wanted
			if (!ascending) {
				index.reverse();
			}
			
			return index;
		}
		
		return null;
	},
	
	/** INTERNAL FUNCTION, do not use directly */
	_quickSort: function(left, right, d){
		var input = this;
		if (left >= right){
			return;
		}
		var j = right, i = left;
		var size = right - left;
		//var pivotPoint = input[uint((right>>>1) + (left>>>1))], t;
		var pivotPoint = input[((right>>>1) + (left>>>1)) >>> 0], t;
		do {
			if (size < 9) {
				pivotPoint = input[left];
				do {
					do {
						left++;
						if (input[left] < pivotPoint) {
							pivotPoint = input[left];
							do { // this section can be improved.
								input[left--] = input[left];
							} while (left > i && pivotPoint < input[left]);
							input[left] = pivotPoint;
						}
					} while (left < right);
					i++;
					left = i;
					pivotPoint = input[left];
				} while (i < right);
				return;
			}
			while (left < right) {
				if (input[right] > pivotPoint){
					do { right--; }
					while (input[right] > pivotPoint);
				}
				if (input[left] < pivotPoint){
					do { left++; }
					while (input[left] < pivotPoint);
				}
				if (left < right) {
					t = input[left];
					input[left] = input[right];
					input[right] = t;
					left++;
					right--;
				}
			}
			if (right) {
				if (left === right) {
					if (input[left] < pivotPoint){
						left++;
					}else if (input[right] > pivotPoint){
						right--;
					}
				}
				if (i < right) {
					input._quickSort(i, right, d + 1);
				}
			}
			left |= int(!left) & int(!right);
			if (j <= left){
				return;
			}
			i = left;
			right = j;
			//pivotPoint = input[uint((right >>> 1) + (left >>> 1))];
			pivotPoint = input[((right >>> 1) + (left >>> 1)) >>> 0];
			size = right - left;
			d++;
		} while (true);
	},

	/** INTERNAL FUNCTION, do not use directly */
	_indexedQuickSort: function(indexed, left, right, d){
		var input = this;
		if (left >= right){
			return;
		}
		
		// status
		var j;
		var i;
		var size = (j = right) - (i = left);
		//var pivotPoint = (input[uint((right>>>1) + (left>>>1))]);
		var pivotPoint = (input[((right>>>1) + (left>>>1)) >>> 0]);
		
		// temps
		var pivotIndex;
		var temp;
		var temp2;
		
		do {
			
			//{ part 1
			if (size < 9) {
				pivotPoint = input[left];
				do {
					do {
						left++;
						temp = input[left];
						if (temp < pivotPoint) {
							
							pivotIndex = indexed[left];
							pivotPoint = temp;
							
							do {
								
								// change vals
								input[left] = input[left - 1];
								
								// change indices
								indexed[left] = indexed[left - 1];
								
								left--;
								
							} while (left > i && pivotPoint < input[left]);
							
							// change vals
							input[left] = pivotPoint;
							
							// change indices
							indexed[left] = pivotIndex;
						}
					} while (left < right);
					i++;
					pivotPoint = input[left = i];
				} while (i < right);
				return;
			}
			//}
			
			//{ part 2
			while (left < right) {
				if (input[right] > pivotPoint) {
					do {
						right--;
					} while (input[right] > pivotPoint);
				}
				if (input[left] < pivotPoint) {
					do {
						left++;
					} while (input[left] < pivotPoint);
				}
				if (left < right) {
					
					// flip values
					temp = input[left];
					input[left] = input[right];
					input[right] = temp;
					
					// flip indices
					temp2 = indexed[left];
					indexed[left] = indexed[right];
					indexed[right] = temp2;
					
					left++;
					right--;
				}
			}
			//}
			
			//{ part 2
			if (right) {
				if (left === right) {
					if (input[left] < pivotPoint) {
						left++;
					}else if (input[right] > pivotPoint) {
						right--;
					}
				}
				if (i < right) {
					
					// recurse
					input._indexedQuickSort(indexed, i, right, d + 1);
					
				}
			}
			//}
			
			left |= int(!left) & int(!right);
			if (j <= left) {
				return;
			}
			i = left;
			right = j;
			//pivotPoint = input[uint((right >>> 1) + (left >>> 1))];
			pivotPoint = input[((right >>> 1) + (left >>> 1)) >>> 0];
			size = right - left;
			d++;
		} while (true);
	},
	
	
	next: function(obj, wrap = false){
		var list = this;
		if (list == null) {
			return null;
		}
		var i = list.indexOf(obj);
		if (i > -1) {
			return (wrap && i >= (list.length - 1)) ? list[0] : list[i + 1];
		}
		return null;
	},
	prev: function(obj, wrap = false){
		var list = this;
		if (list == null) {
			return null;
		}
		var i = list.indexOf(obj);
		if (i > 0) {
			return wrap ? list[list.length - 1] : list[i - 1];
		}
		return null;
	},
	
	
	where: function(callback){
		var list = this;
		if (list == null) {
			return null;
		}
		var results = [];
		for (var i = 0; i<list.length; i++){
			var obj = list[i];
			if (callback(obj) == true){
				results.push(obj);
			}
		}
		return results;
	},
	
	props: function(prop, defaultVal = null){
		var list = this;
		if (list == null) {
			return null;
		}
		var results = [];
		for (var i = 0; i<list.length; i++){
			var obj = list[i];
			results.push(obj != null ? obj[prop] : defaultVal);
		}
		return results;
	},
	
	
	none:null
};

// register funcs
UB.registerFuncs(Array.prototype, arrayFuncs);

nightfury7 / universalbasics.js

Push — master ( 8d43c8...457e33 )

arrayFuncs.props A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
